{
 "cells": [
  {
   "cell_type": "markdown",
   "id": "5ac75915",
   "metadata": {},
   "source": [
    "# Reinforce 算法（with and without baseline）"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "b53205a7",
   "metadata": {},
   "outputs": [],
   "source": [
    "import gym\n",
    "import torch\n",
    "import torch.nn.functional as F\n",
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "from tqdm import tqdm\n",
    "import scipy.linalg as lg\n",
    "import random\n",
    "from torch.optim.lr_scheduler import ExponentialLR"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "fb5ba593",
   "metadata": {},
   "outputs": [],
   "source": [
    "class quantum_gate:\n",
    "    def __init__(self,  \n",
    "                 gate_time = 1, \n",
    "                 dt = 0.05, \n",
    "                 target_gate = np.mat([[0, 1], [1, 0]], dtype = complex), \n",
    "                 preprocess = False):\n",
    "        self.preprocess = preprocess\n",
    "        self.dimension = np.shape(target_gate)[0]\n",
    "        self.gate = np.mat(np.identity(self.dimension), dtype = complex)\n",
    "        self.target_gate = target_gate #默认目标是实现X门\n",
    "        self.nstep = 0\n",
    "        self.gate_time = gate_time\n",
    "        self.dt = dt\n",
    "        self.sx = np.mat([[0, 1], [1, 0]], dtype = complex)\n",
    "        self.sz = np.mat([[1, 0], [0, -1]], dtype = complex)\n",
    "        self.sy = np.mat([[0, -1j], [1j, 0]], dtype = complex)\n",
    "        self.observe_state()\n",
    "        self.strength_low = -6\n",
    "        self.strength_high = 6 \n",
    "\n",
    "        self.name = \"optimal quantum gate\"\n",
    "        self.done = 0\n",
    "        self.fidelity = [0]\n",
    "        \n",
    "    \n",
    "    \n",
    "    def observe_state(self):#因为神经网络不能识别复数矩阵，所以要把实部虚部分开，并展成一维数组，喂给神经网络   \n",
    "        if self.preprocess == False:\n",
    "            self.state = []\n",
    "            temp = np.array(self.gate).flatten()\n",
    "            for item in temp:\n",
    "                self.state.append(item.real)\n",
    "                self.state.append(item.imag)\n",
    "            \n",
    "            \n",
    "#             self.state.append(self.nstep)         #Reinforce算法对于加入时间信息反而会使得算法表现变差\n",
    "            \n",
    "    \n",
    "            self.state = np.array(self.state)\n",
    "        else:\n",
    "            #预处理模块，我尝试过把单量子门的两个欧拉角先算出来再喂给神经网络，但是效果不理想\n",
    "            determinant = np.linalg.det(self.gate)\n",
    "            phase = np.sqrt(determinant)\n",
    "            SU2_gate = self.gate / phase\n",
    "\n",
    "            a = SU2_gate[0,0]\n",
    "            b = SU2_gate[0,1]\n",
    "            a_mod = np.sqrt(a.real ** 2 + a.imag ** 2)\n",
    "            b_mod = np.sqrt(b.real ** 2 + b.imag ** 2)\n",
    "            A = a.real / a_mod if a_mod != 0 else 0\n",
    "            B = b.imag / b_mod if b_mod != 0 else 0\n",
    "            \n",
    "            beta = (np.arccos(a_mod) + np.arcsin(b_mod)) / np.pi\n",
    "            alpha = (np.arccos(A) + np.arcsin(B)) / np.pi\n",
    "            gamma = (np.arccos(A) - np.arcsin(B)) / np.pi\n",
    "\n",
    "            self.state = np.array([beta, alpha, gamma])\n",
    "        return\n",
    "    \n",
    "    def reset(self):\n",
    "        self.gate = np.mat(np.identity(self.dimension), dtype = complex)\n",
    "        self.observe_state()\n",
    "        self.nstep = 0\n",
    "        self.done = 0\n",
    "        self.fidelity = [0]\n",
    "        return self.state\n",
    "    \n",
    "    def Hamiltonian(self, strength):\n",
    "        H = -strength * self.sx + self.sz * 1\n",
    "\n",
    "        #实际样品的sz强度应该远小于sx\n",
    "        return H\n",
    "    \n",
    "    def reward(self):\n",
    "        projection = self.target_gate.H * self.gate\n",
    "        trace = np.array(projection.trace()).flatten()[0] \n",
    "        fidelity = ((trace/self.dimension).real)**2 + ((trace/self.dimension).imag)**2\n",
    "\n",
    "        err = 1 - fidelity\n",
    "\n",
    "        reward = -np.log(err) if self.done == 1 else 0\n",
    "        \n",
    "        #reward做一个三次方\n",
    "#         reward = reward ** 3\n",
    "        #我曾尝试过的对Reward函数进行改变，不过效果不好\n",
    "    \n",
    "    \n",
    "        self.fidelity.append(fidelity)\n",
    "        return [reward, fidelity]\n",
    "    \n",
    "    def step(self, strength):\n",
    "        U = lg.expm(-1j * self.Hamiltonian(strength) * self.dt)\n",
    "        U = np.mat(U)\n",
    "        self.gate = U * self.gate\n",
    "        self.observe_state()\n",
    "        \n",
    "        \n",
    "        self.nstep += 1\n",
    "        self.done = self.nstep * self.dt >= self.gate_time\n",
    "        reward, fidelity = self.reward()\n",
    "        \n",
    "        return [self.state, reward, self.done, fidelity, self.gate]\n",
    "        \n",
    "        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "a05a16c4",
   "metadata": {},
   "outputs": [],
   "source": [
    "class PolicyNet(torch.nn.Module):\n",
    "    def __init__(self, state_dim, hidden_dim, action_dim):\n",
    "        super(PolicyNet, self).__init__()\n",
    "        self.fc1 = torch.nn.Linear(state_dim, hidden_dim)\n",
    "        self.fc2 = torch.nn.Linear(hidden_dim, action_dim)\n",
    "\n",
    "    def forward(self, x):\n",
    "        x = F.relu(self.fc1(x))\n",
    "        return  F.softmax(self.fc2(x),dim=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "847a8dd0",
   "metadata": {},
   "outputs": [],
   "source": [
    "class ValueNet(torch.nn.Module):\n",
    "    def __init__(self, state_dim, hidden_dim, action_dim):\n",
    "        super(ValueNet, self).__init__()\n",
    "        self.fc1 = torch.nn.Linear(state_dim, hidden_dim)\n",
    "        self.fc2 = torch.nn.Linear(hidden_dim, action_dim)\n",
    "\n",
    "    def forward(self, x):\n",
    "        x = F.relu(self.fc1(x))\n",
    "        return  self.fc2(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "061cf856",
   "metadata": {},
   "outputs": [],
   "source": [
    "class Reinforce:\n",
    "    def __init__(self, state_dim, hidden_dim, action_dim, learning_rate, gamma, device, baseline = False):\n",
    "        self.policy_net = PolicyNet(state_dim, hidden_dim, action_dim).to(device)\n",
    "        # 我曾尝试过让学习率衰减来增加最后收敛的稳定性，不过效果不好：算法会收敛到一个明显不是最优的策略。所以这里的optimizer在后面并没有被调用\n",
    "        self.optimizer= torch.optim.Adam(self.policy_net.parameters(), lr=learning_rate) # 使用Adam优化器\n",
    "        self.scheduler = ExponentialLR(self.optimizer, gamma=0.9)\n",
    "        self.gamma = gamma # 折扣衰减因子\n",
    "        self.baseline = baseline\n",
    "        if baseline == True:\n",
    "            self.value_net = ValueNet(state_dim, 64, 1).to(device)\n",
    "            self.value_optimizer = torch.optim.Adam(self.value_net.parameters(), lr = learning_rate)\n",
    "\n",
    "    def take_action(self, state): # 根据动作概率分布随机采样\n",
    "        state = torch.tensor([state], dtype=torch.float).to(device)\n",
    "        probs = self.policy_net(state).to(device)\n",
    "        action_dist = torch.distributions.Categorical(probs)\n",
    "        action = action_dist.sample()\n",
    "        return action.item()\n",
    "\n",
    "    def update(self, transition_dict):\n",
    "        reward_list = transition_dict['rewards']\n",
    "        state_list = transition_dict['states']\n",
    "        action_list = transition_dict['actions']\n",
    "        \n",
    "        if self.baseline == False:\n",
    "            G = 0\n",
    "            self.optimizer.zero_grad()\n",
    "            for i in reversed(range(len(reward_list))): # 从最后一步算起\n",
    "                reward = reward_list[i]\n",
    "                state = torch.tensor([state_list[i]], dtype=torch.float).to(device)\n",
    "                action = torch.tensor([action_list[i]]).view(-1, 1).to(device)\n",
    "                log_prob = torch.log(self.policy_net(state).gather(1, action)).to(device)\n",
    "                G = self.gamma * G + reward          \n",
    "                loss = - log_prob * G # 每一步的损失函数\n",
    "                loss.backward() # 反向传播计算梯度\n",
    "            self.optimizer.step() # 梯度下降\n",
    "        else:\n",
    "            #训练价值估计网络\n",
    "            G = 0\n",
    "            self.value_optimizer.zero_grad()\n",
    "            for i in reversed(range(len(reward_list))): # 从最后一步算起\n",
    "                reward = reward_list[i]\n",
    "                state = torch.tensor([state_list[i]], dtype=torch.float).to(device)\n",
    "                value = self.value_net(state).to(device)\n",
    "                value = value.float()\n",
    "                G = self.gamma * G + reward          \n",
    "                loss = F.mse_loss(value, torch.tensor([[G]]).to(device).float())\n",
    "                loss.backward() # 反向传播计算梯度\n",
    "            self.value_optimizer.step()\n",
    "            \n",
    "            #训练动作网络\n",
    "            G = 0\n",
    "            self.optimizer.zero_grad()\n",
    "            for i in reversed(range(len(reward_list))): # 从最后一步算起\n",
    "                reward = reward_list[i]\n",
    "                state = torch.tensor([state_list[i]], dtype=torch.float).to(device)\n",
    "                action = torch.tensor([action_list[i]]).view(-1, 1).to(device)\n",
    "                log_prob = torch.log(self.policy_net(state).gather(1, action)).to(device)\n",
    "                value = self.value_net(state).to(device)\n",
    "                G = self.gamma * G + reward          \n",
    "                delta = G - value #误差\n",
    "                loss = - log_prob * delta # 每一步的损失函数\n",
    "                loss.backward() # 反向传播计算梯度\n",
    "            self.optimizer.step() # 梯度下降\n",
    "            "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 9,
   "id": "8e5cfdad",
   "metadata": {},
   "outputs": [],
   "source": [
    "def smoothed_curve(data, N = 50):\n",
    "    windows = []\n",
    "    for i in range(len(data)):\n",
    "        temp = np.array(data[max(0, i - N):i + 1])\n",
    "        windows.append(temp.mean())\n",
    "    return windows"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "id": "31e7f044",
   "metadata": {},
   "outputs": [],
   "source": [
    "def dis_to_con(discrete_action, env, action_dim): # 离散动作转回连续的函数\n",
    "    action_lowbound = env.strength_low # 连续动作的最小值\n",
    "    action_upbound = env.strength_high # 连续动作的最大值\n",
    "    return action_lowbound + (discrete_action / (action_dim - 1)) * (action_upbound - action_lowbound)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "c6fa8a83",
   "metadata": {},
   "source": [
    "# 不加基线"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "id": "54445bb6",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Iteration 0: 100%|█████████████████████████████████████| 3000/3000 [01:58<00:00, 25.29it/s, episode=3000, return=2.523]\n",
      "Iteration 1: 100%|█████████████████████████████████████| 3000/3000 [01:55<00:00, 25.90it/s, episode=6000, return=4.053]\n",
      "Iteration 2: 100%|█████████████████████████████████████| 3000/3000 [01:51<00:00, 26.84it/s, episode=9000, return=3.503]\n",
      "Iteration 3: 100%|████████████████████████████████████| 3000/3000 [01:52<00:00, 26.73it/s, episode=12000, return=3.732]\n",
      "Iteration 4: 100%|████████████████████████████████████| 3000/3000 [01:55<00:00, 26.05it/s, episode=15000, return=4.541]\n",
      "Iteration 5: 100%|████████████████████████████████████| 3000/3000 [01:51<00:00, 26.88it/s, episode=18000, return=5.552]\n",
      "Iteration 6: 100%|████████████████████████████████████| 3000/3000 [01:54<00:00, 26.29it/s, episode=21000, return=3.526]\n",
      "Iteration 7: 100%|████████████████████████████████████| 3000/3000 [01:53<00:00, 26.50it/s, episode=24000, return=4.626]\n",
      "Iteration 8: 100%|████████████████████████████████████| 3000/3000 [01:53<00:00, 26.40it/s, episode=27000, return=4.690]\n",
      "Iteration 9: 100%|████████████████████████████████████| 3000/3000 [01:55<00:00, 26.05it/s, episode=30000, return=3.398]\n"
     ]
    }
   ],
   "source": [
    "learning_rate = 1e-3\n",
    "num_episodes = 30000\n",
    "hidden_dim = 128\n",
    "gamma = 0.98\n",
    "device = torch.device(\"cuda\") if torch.cuda.is_available() else torch.device(\"cpu\")\n",
    "\n",
    "\n",
    "env = quantum_gate()\n",
    "torch.manual_seed(0)\n",
    "state_dim = np.shape(env.state)[0]\n",
    "action_dim = 13\n",
    "agent = Reinforce(state_dim, hidden_dim, action_dim, learning_rate, gamma, device)\n",
    "\n",
    "return_list = []\n",
    "for i in range(10):\n",
    "    with tqdm(total=int(num_episodes/10), desc='Iteration %d' % i) as pbar:\n",
    "        for i_episode in range(int(num_episodes/10)):\n",
    "            episode_return = 0\n",
    "            transition_dict = {'states': [], 'actions': [], 'next_states': [], 'rewards': [], 'dones': []}\n",
    "            state = env.reset()\n",
    "            done = False\n",
    "            while not done:\n",
    "                action = agent.take_action(state)\n",
    "                action_continuous = dis_to_con(action, env, action_dim)\n",
    "                next_state, reward, done, fidelity, _ = env.step(action_continuous)\n",
    "                transition_dict['states'].append(state)\n",
    "                transition_dict['actions'].append(action)\n",
    "                transition_dict['next_states'].append(next_state)\n",
    "                transition_dict['rewards'].append(reward)\n",
    "                transition_dict['dones'].append(done)\n",
    "                state = next_state\n",
    "                episode_return += reward\n",
    "            return_list.append(episode_return)\n",
    "            agent.update(transition_dict)\n",
    "            if (i_episode+1) % 10 == 0:\n",
    "                pbar.set_postfix({'episode': '%d' % (num_episodes/10 * i + i_episode+1), 'return': '%.3f' % np.mean(return_list[-10:])})\n",
    "            pbar.update(1)\n",
    "            \n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "id": "68ec7e57",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Last fidelity =  0.8489237208221215\n",
      "Average fidelity =  0.9924713550012765\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 432x288 with 1 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "episodes_list = list(range(len(return_list)))\n",
    "plt.plot(episodes_list,return_list)\n",
    "plt.xlabel('Episodes')\n",
    "plt.ylabel('Returns')\n",
    "ans = smoothed_curve(return_list)\n",
    "plt.plot(ans)\n",
    "\n",
    "plt.figure()\n",
    "error=np.array(return_list)\n",
    "plt.plot(episodes_list,1 - np.exp(-np.array(return_list)))\n",
    "plt.plot(episodes_list,1 - np.exp(-np.array(ans)))\n",
    "plt.xlabel('Episode')\n",
    "plt.ylabel('Fidelity')\n",
    "\n",
    "print(\"Last fidelity = \", 1 - np.exp(-np.array(return_list))[-1])\n",
    "print(\"Average fidelity = \", 1 - np.exp(-np.array(ans))[-1])"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "a01372c6",
   "metadata": {},
   "source": [
    "# 加入基线"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "bd092164",
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Iteration 0: 100%|█████████████████████████████████████| 3000/3000 [03:11<00:00, 15.63it/s, episode=3000, return=5.877]\n",
      "Iteration 1: 100%|█████████████████████████████████████| 3000/3000 [03:23<00:00, 14.71it/s, episode=6000, return=6.365]\n",
      "Iteration 2: 100%|█████████████████████████████████████| 3000/3000 [03:31<00:00, 14.18it/s, episode=9000, return=6.192]\n",
      "Iteration 3: 100%|████████████████████████████████████| 3000/3000 [03:30<00:00, 14.24it/s, episode=12000, return=5.920]\n",
      "Iteration 4: 100%|████████████████████████████████████| 3000/3000 [03:28<00:00, 14.41it/s, episode=15000, return=6.159]\n",
      "Iteration 5: 100%|████████████████████████████████████| 3000/3000 [03:19<00:00, 15.04it/s, episode=18000, return=6.192]\n",
      "Iteration 6: 100%|████████████████████████████████████| 3000/3000 [03:20<00:00, 14.96it/s, episode=21000, return=6.192]\n",
      "Iteration 7: 100%|████████████████████████████████████| 3000/3000 [02:55<00:00, 17.14it/s, episode=24000, return=6.192]\n",
      "Iteration 8: 100%|████████████████████████████████████| 3000/3000 [02:54<00:00, 17.16it/s, episode=27000, return=6.192]\n",
      "Iteration 9: 100%|████████████████████████████████████| 3000/3000 [02:57<00:00, 16.90it/s, episode=30000, return=6.192]\n"
     ]
    }
   ],
   "source": [
    "learning_rate = 1e-3\n",
    "num_episodes = 30000\n",
    "hidden_dim = 128\n",
    "gamma = 0.98\n",
    "device = torch.device(\"cuda\") if torch.cuda.is_available() else torch.device(\"cpu\")\n",
    "\n",
    "\n",
    "env = quantum_gate()\n",
    "torch.manual_seed(0)\n",
    "state_dim = np.shape(env.state)[0]\n",
    "action_dim = 13\n",
    "agent = Reinforce(state_dim, hidden_dim, action_dim, learning_rate, gamma, device, baseline=True)\n",
    "\n",
    "return_list = []\n",
    "for i in range(10):\n",
    "    with tqdm(total=int(num_episodes/10), desc='Iteration %d' % i) as pbar:\n",
    "        for i_episode in range(int(num_episodes/10)):\n",
    "            episode_return = 0\n",
    "            transition_dict = {'states': [], 'actions': [], 'next_states': [], 'rewards': [], 'dones': []}\n",
    "            state = env.reset()\n",
    "            done = False\n",
    "            while not done:\n",
    "                action = agent.take_action(state)\n",
    "                action_continuous = dis_to_con(action, env, action_dim)\n",
    "                next_state, reward, done, fidelity, _ = env.step(action_continuous)\n",
    "                transition_dict['states'].append(state)\n",
    "                transition_dict['actions'].append(action)\n",
    "                transition_dict['next_states'].append(next_state)\n",
    "                transition_dict['rewards'].append(reward)\n",
    "                transition_dict['dones'].append(done)\n",
    "                state = next_state\n",
    "                episode_return += reward\n",
    "            return_list.append(episode_return)\n",
    "            agent.update(transition_dict)\n",
    "            if (i_episode+1) % 10 == 0:\n",
    "                pbar.set_postfix({'episode': '%d' % (num_episodes/10 * i + i_episode+1), 'return': '%.3f' % np.mean(return_list[-10:])})\n",
    "            pbar.update(1)\n",
    "            \n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 37,
   "id": "c28d71fe",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "Last fidelity =  0.9979538948375978\n",
      "Average fidelity =  0.9979538948375978\n"
     ]
    },
    {
     "data": {
      "image/png": "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\n",
      "text/plain": [
       "<Figure size 720x216 with 2 Axes>"
      ]
     },
     "metadata": {
      "needs_background": "light"
     },
     "output_type": "display_data"
    }
   ],
   "source": [
    "episodes_list = list(range(len(return_list)))\n",
    "plt.figure(figsize=(10,3))\n",
    "plt.subplot(1,2,1)\n",
    "plt.plot(episodes_list,return_list)\n",
    "plt.xlabel('Episodes')\n",
    "plt.ylabel('Returns')\n",
    "ans = smoothed_curve(return_list)\n",
    "plt.plot(ans)\n",
    "\n",
    "plt.subplot(1,2,2)\n",
    "error=np.array(return_list)\n",
    "plt.plot(episodes_list,1 - np.exp(-np.array(return_list)))\n",
    "\n",
    "plt.plot(episodes_list,1 - np.exp(-np.array(ans)))\n",
    "plt.xlabel('Episode')\n",
    "plt.ylabel('Fidelity')\n",
    "\n",
    "print(\"Last fidelity = \", 1 - np.exp(-np.array(return_list))[-1])\n",
    "print(\"Average fidelity = \", 1 - np.exp(-np.array(ans))[-1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "bdee52b5",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.9.7"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}
